
# int num = 5  # Mal.
num = 5
print(num, type(num))

num = 5.
print(num, type(num))

cad = 'Hola mundo!'
print(cad, type(cad))

5 <class 'int'>
5.0 <class 'float'>
Hola mundo! <class 'str'>


num = 11
print('Este es mi número favorito:', num)            # Cast automático.
print('Este es mi número favorito: ' + str(num))     # Nosotros hacemos cast.
print('Este es mi número favorito: {}'.format(num))  # Forma más interesante.
print(f'Este es mi número favorito: {num}')  # Aún más interesante y versátil.

Este es mi número favorito: 11
Este es mi número favorito: 11
Este es mi número favorito: 11
Este es mi número favorito: 11


# Importacion.
# import librosa
from scipy.io import wavfile
import IPython
import os
import numpy as np
import matplotlib.pyplot as plt


# Directorios que usaremos.
cwd = os.getcwd()
audio_input_path = os.path.join(cwd, os.path.join('audio', '_input'))  # cambiar '_input' por 'examples'
audio_output_path = os.path.join(cwd, os.path.join('audio', '_output'))
print(f'Directorio con los audios de entrada: {audio_input_path}')
print(f'Directorio donde guardaremos los audios generados: {audio_output_path}\n')

Directorio con los audios de entrada: /home/sfandres/Documents/Git/uex-audiopy/audio/_input
Directorio donde guardaremos los audios generados: /home/sfandres/Documents/Git/uex-audiopy/audio/_output


# Cargamos el archivo de audio.
filename = os.path.join(audio_input_path, 'sample1_stereo.wav')
# audio_data, sample_rate = librosa.load(filename, sr=None, mono=False)
sample_rate, audio_data = wavfile.read(filename)
print(f'Frecuencia de muestreo (sample rate): {sample_rate/1000} kHz')

Frecuencia de muestreo (sample rate): 44.1 kHz


IPython.display.Audio(audio_data.T, rate=sample_rate) # .T se pasa únicamente si es audio estéreo.


# Mostrar informacion (sonido estéreo).
print('Datos de audio (estereo):')
print(f'- Tamaño:     {audio_data.shape}')
print(f'- 1º canal:   {audio_data[:5, 0]}...')
print(f'- 2º canal:   {audio_data[:5, 1]}...')
print(f'- Resolucion: {type(audio_data[0,0])}\n')

Datos de audio (estereo):
- Tamaño:     (5384326, 2)
- 1º canal:   [137 140  91   4 -69]...
- 2º canal:   [ 66  38   0 -10  45]...
- Resolucion: <class 'numpy.int16'>


# Convertimos a mono mediante la media por canal (simplificacion).
new_data_mono = audio_data.mean(axis=1)  # Column-wise.
print('Nuevos datos de audio (mono):')
print(f'- Nuevo tamaño: {new_data_mono.shape}')
print(f'- Canal unico:  {new_data_mono[:5]}...')

# Mantenemos la misma resolucion que antes.
new_data_mono = new_data_mono.astype(np.int16)
print(f'- Resolucion:   {type(new_data_mono[0])}\n')

Nuevos datos de audio (mono):
- Nuevo tamaño: (5384326,)
- Canal unico:  [101.5  89.   45.5  -3.  -12. ]...
- Resolucion:   <class 'numpy.int16'>


# Guardamos el archivo mono a un fichero de tipo wav.
wavfile.write(
    filename=os.path.join(audio_output_path, 'sample1_mono.wav'),
    rate=sample_rate,
    data=new_data_mono
)


IPython.display.Audio(new_data_mono, rate=sample_rate)


!ls -sh audio/_input/sample1_stereo.wav
!ls -sh audio/_output/sample1_mono.wav

21M audio/_input/sample1_stereo.wav
11M audio/_output/sample1_mono.wav


print(f'Frecuencia de muestreo (sample rate): {sample_rate/1000} kHz\n')

Frecuencia de muestreo (sample rate): 44.1 kHz


# Cargamos los archivos de audio.
sample_rate_48, audio_data_48 = wavfile.read(filename=os.path.join(audio_input_path, 'sample_48kHz.wav'))
sample_rate_24, audio_data_24 = wavfile.read(filename=os.path.join(audio_input_path, 'sample_24kHz.wav'))

# Otro ejemplo sería: audio_data, sample_rate = librosa.load(filename)

print(f'{audio_data_48.shape}\n')  # Audio mono
print(f'{audio_data_24.shape}\n')  # Audio mono

(176542,)

(88271,)


IPython.display.Audio(audio_data_48, rate=sample_rate_48)


IPython.display.Audio(audio_data_24, rate=sample_rate_24)


!ls -sh audio/_input/sample_48kHz.wav
!ls -sh audio/_input/sample_24kHz.wav

348K audio/_input/sample_48kHz.wav
176K audio/_input/sample_24kHz.wav


ampl_values_48 = len(audio_data_48)
ampl_values_24 = len(audio_data_24)
print(f'Número de muestras del audio con fs=48 kHz (valores de amplitud): {ampl_values_48}')
print(f'Número de muestras del audio con fs=24 kHz (valores de amplitud): {ampl_values_24}')

Número de muestras del audio con fs=48 kHz (valores de amplitud): 176542
Número de muestras del audio con fs=24 kHz (valores de amplitud): 88271


# Construimos el array para el eje x que representa el tiempo de la grabación.
# Tiene la forma: np.arange(Vi, Vf, P). Explicado a continuación.
t1 = np.arange(0, ampl_values_48/sample_rate_48, 1/sample_rate_48)
t2 = np.arange(0, ampl_values_24/sample_rate_24, 1/sample_rate_24)


# Creamos la figura.
fig, ax = plt.subplots(2, 1, figsize=(12, 6), sharex=True)

# Solo mostramos las primeras 50 muestras de amplitud (por claridad).
end = 50

# Señal a 48 kHz.
ax[0].plot(t1[:end], audio_data_48[:end], marker='X')
ax[0].set_title(f'Audio en el dominio del tiempo muestreado a {sample_rate_48} Hz')
ax[0].set_ylabel('Amplitud')
ax[0].grid(True)

# Señal a 24 kHz.
# Utilizamos ratio para ajustar el eje x de ambas gráficas
# ya que la fs es menor en esta señal.
ratio = sample_rate_48 / sample_rate_24  
ax[1].plot(t2[:int(end/ratio)], audio_data_24[:int(end/ratio)], c='tab:red', marker='X')
ax[1].set_title(f'Audio en el dominio del tiempo muestreado a {sample_rate_24} Hz')
ax[1].set_xlabel('Tiempo (s)')
ax[1].set_ylabel('Amplitud')
ax[1].grid(True)

# Mostramos la figura.
plt.tight_layout()
plt.show()


# La longitud del array de datos y el
# sample rate (frecuencia de muestreo).
n = len(audio_data_48)
Fs = sample_rate_48

# Working with stereo audio, there are two channels in the audio data.
# Let's retrieve each channel seperately:
# ch1 = np.array([data[i][0] for i in range(n)]) #channel 1
# ch2 = np.array([data[i][1] for i in range(n)]) #channel 2
# We can then perform a Fourier analysis on the first
# channel to see what the spectrum looks like.

# Calculando la Transformada Rapida de Fourier (FFT) en audio mono.
ch_Fourier = np.fft.fft(audio_data_48)  # ch1

# Solo miramos frecuencia por debajo de Fs/2
# (Nyquist-Shannon) --> Spectrum.
abs_ch_Fourier = np.absolute(ch_Fourier[:n//2])

# Graficamos.
plt.plot(np.linspace(0, Fs/2, n//2), abs_ch_Fourier)
plt.ylabel('Amplitud', labelpad=10)
plt.xlabel('$f$ (Hz)', labelpad=10)
plt.show()


# Definimos epsilon: la parte de la energia
# del espectro que no conservamos.
eps = [1e-5, .02, .041, .063, .086, .101, .123]

# Jugamos con los valores de epsilon (CAMBIAD ESTO).
eps = eps[0]
print(f'Epsilon: {eps}')

# Calculamos el valor de corte para esta energia.
thr_spec_energy = (1 - eps) * np.sum(abs_ch_Fourier)
print(f'Valor de corte para la energia del espectro: {thr_spec_energy}')

# Integral de la frecuencia --> energia del espectro.
spec_energy = np.cumsum(abs_ch_Fourier)

# Mascara (array booleano) que compara el valor
# de corte con la energia del espectro.
frequencies_to_remove = thr_spec_energy < spec_energy  
print(f'Mascara: {frequencies_to_remove}')

# La frecuencia f0 por la que cortamos el espectro.
f0 = (len(frequencies_to_remove) - np.sum(frequencies_to_remove)) * (Fs/2) / (n//2)
print(f'Frecuencia de corte f0 (Hz): {int(f0)}')

# Graficamos.
plt.axvline(f0, color='r')
plt.plot(np.linspace(0, Fs/2, n//2), abs_ch_Fourier)
plt.ylabel('Amplitud')
plt.xlabel('$f$ (Hz)')
plt.show()

Epsilon: 1e-05
Valor de corte para la energia del espectro: 50667270320.0895
Mascara: [False False False ...  True  True  True]
Frecuencia de corte f0 (Hz): 23992


# Definimos los nombres de los audios comprimidos.
wav_compressed_file = "sample_48kHz_compressed.wav"

# Calculamos el factor D de downsampling.
D = int(Fs / f0)
print(f'Factor de downsampling: {D}')

# Obtenemos los nuevos datos (slicing with stride).
new_data = audio_data_48[::D]

# Escribimos los datos a un archivo de tipo wav.
wavfile.write(
    filename=os.path.join(audio_output_path, wav_compressed_file),
    rate=int(Fs/D),
    data=new_data
)

# Cargamos el nuevo archivo.
new_sample_rate, new_audio_data = wavfile.read(filename=os.path.join(audio_output_path, wav_compressed_file))

Factor de downsampling: 2


IPython.display.Audio(new_audio_data, rate=new_sample_rate)


!ls -sh audio/_output/sample_48kHz_compressed.wav

176K audio/_output/sample_48kHz_compressed.wav


fig, ax = plt.subplots(2, 1, figsize=(12, 8), sharex=True)

Pxx, freqs, bins, im = ax[0].specgram(audio_data_48, NFFT=1024, Fs=sample_rate_48, noverlap=512)
ax[0].set_title('Espectograma del audio original')
ax[0].set_ylabel('Frecuencia (Hz)')
ax[0].grid(True)

Pxx, freqs, bins, im = ax[1].specgram(new_audio_data, NFFT=1024, Fs=new_sample_rate, noverlap=512)
ax[1].set_title('Espectrograma del audio reducido/comprimido')
ax[1].set_xlabel('Tiempo (s)')
ax[1].set_ylabel('Frecuencia (Hz)')
ax[1].grid(True)

plt.tight_layout()
plt.show()


# # Ignorar: Codigo para reducir un archivo de audio truncando


# # Input data.
# audio_examples_input_path = os.path.join(cwd, os.path.join('audio', 'examples'))
# filename = os.path.join(audio_examples_input_path, 'interstellar.wav')
# sample_rate_v0, audio_data_v0 = wavfile.read(filename)
# print(f'Shape of the input audio data: {audio_data_v0.shape}\n')


# # Slicing with stride (stereo).
# new_data_v0 = audio_data_v0[:10856495//4, :]

# # Writing to a wav file.
# wavfile.write(
#     filename=os.path.join(audio_examples_input_path, 'interstellar2.wav'),
#     rate=sample_rate_v0,
#     data=new_data_v0
# )

# # Loading the new audio data.
# filename = os.path.join(audio_examples_input_path, 'interstellar2.wav')
# sample_rate_v1, audio_data_v1 = wavfile.read(filename)
# print(f'Shape of the input audio data min: {audio_data_v1.shape}')
# print(f'Reduction (%): {int((len(audio_data_v0)-len(audio_data_v1))*100/len(audio_data_v0))}')


# IPython.display.Audio(audio_data_v1.T, rate=sample_rate_v1)

Turno	Tiempo (')	Tarea
Alumnos	20	Acceder al GitHub de la práctica y seguir los pasos para replicar mi repositorio en local y echarlo a andar (hay que seguir el apartado Getting started).
Profesor	60	Explicar el contenido de este notebook.
Alumnos	∞	Realizar el ejercicio de clase que se divide en dos partes: crear un entorno de conda desde cero (apartado Working on your own from scratch) y analizar ondas de audio con Python3.

Sesión 4 de SM: Introducción al procesamiento de audio con Python¶

Organización de la clase¶

Objetivos¶

Bibliografía consultada¶

Introducción¶

¿Qué es un entorno de Anaconda?¶

Jupyter lab vs Jupyter notebooks¶

Breve introducción a Python3¶

Primeros pasos con audio: sonido estéreo vs mono¶

Importar librerías y módulos de Python¶

Especificar directorios de entrada y salida¶

Cargar el archivo de audio¶

Mostrar principales características de la onda¶

Teoría: Toma de muestras de audio¶

Definición de muestra¶

Frecuencia de muestreo (sample rate)¶

Definición¶

Valores más comunes de frecuencia de muestreo¶

Pregunta sencilla: a mayor frecuencia de muestreo, ¿mayor calidad?¶

Caso real: ¿A qué valor fijamos la frecuencia de muestreo?¶

Cuando el muestreo sale mal: Aliasing¶

Mas teoría: Características de grabación de audio digital¶

Profundidad de bits (bit depth)¶

Ancho de banda (bandwidth)¶

Suele llevar a confusión: Frecuencia de muestreo vs tasa de bits (bitrate)¶

Práctica: Compresión de audio¶

Cargar audios¶

Gráficas características¶

Dominio del tiempo¶

Dominio de la frecuencia: Transformada de Fourier (FFT)¶

Teoría¶

Análisis de Fourier¶

Energia del espectrograma y frecuencia de corte¶

Compresión del archivo¶

Reducción de la resolución de muestreo (downsampling)¶

Espectrograma¶